// 码生成结果页面（支持二维码和条形码）
const drawQrcode = require('../../utils/qrcode.js');
const apiService = require('../../utils/api-service.js');
const MessageUtil = require('../../utils/message-util.js');
const JsBarcodeUtil = require('../../utils/jsbarcode-util.js');

Page({
  data: {
    // 基础数据
    content: '',
    codeType: 'barcode', // 'barcode' 或 'qr'
    barcodeType: '',
    qrType: '',
    typeText: '',
    batchMode: false,
    barcodes: [],
    
    // 样式设置
    foregroundColor: '#000000',
    backgroundColor: '#ffffff',
    barcodeWidth: 300,
    qrSize: 300,
    
    // Canvas 尺寸
    canvasWidth: 300,
    canvasHeight: 120,
    
    // 缩放相关
    scaleRatio: 1,
    batchScaleRatio: 1,
    screenWidth: 0, // 初始为0，将在onLoad时动态获取
    
    // 状态控制
    loading: false,
    loadingText: '正在生成...',
    
    // 离线模式状态
    isOfflineMode: false
  },

  onLoad(options) {
    console.log('码结果页面参数:', options);
    
    // 同步获取屏幕信息（必须在其他计算之前完成）
    this.initScreenInfo();
    
    // 检查离线模式状态
    this.checkOfflineMode();
    
    if (options.data) {
      try {
        const data = JSON.parse(decodeURIComponent(options.data));
        console.log('解析的数据:', data);
        
        // 判断码类型
        const isQR = data.type === 'standard' || data.type === 'micro' || data.qrType || !data.barcodeType;
        const codeType = isQR ? 'qr' : 'barcode';
        
        // 处理批量数据
        let barcodes = [];
        if (data.batchMode) {
          if (isQR) {
            // 二维码批量模式，需要从内容中解析
            const lines = data.content.split('\n').filter(line => line.trim());
            barcodes = lines.map(line => ({ content: line.trim() }));
          } else {
            // 条形码批量模式，内容可能是数组或字符串
            if (Array.isArray(data.content)) {
              barcodes = data.content.map(item => ({ content: item }));
            } else {
              const lines = data.content.split('\n').filter(line => line.trim());
              barcodes = lines.map(line => ({ content: line.trim() }));
            }
          }
        }

        this.setData({
          content: Array.isArray(data.content) ? data.content[0] : data.content || '',
          codeType: codeType,
          barcodeType: data.barcodeType || 'Code 128',
          qrType: data.type || 'standard',
          typeText: this.getTypeText(isQR ? data.type : data.barcodeType),
          batchMode: data.batchMode || false,
          barcodes: barcodes,
          foregroundColor: data.foregroundColor || '#000000',
          backgroundColor: data.backgroundColor || '#ffffff',
          barcodeWidth: data.barcodeWidth || 300,
          qrSize: data.size || 300
        });
        
        // 设置Canvas尺寸和缩放比例（此时screenWidth已经是真实值）
        this.setCanvasSize();
        
        // 保存到历史记录
        this.saveToHistory(data);
        
        // 延迟绘制码
        setTimeout(() => {
          if (this.data.isOfflineMode) {
            console.log('离线模式，使用本地生成');
            // 检查是否为批量生成
            if (data.batchMode) {
              MessageUtil.showError('离线模式下暂不支持批量生成');
              return;
            }
            
            if (isQR) {
              this.generateQRLocally(data);
            } else {
              this.generateBarcodeLocally(data);
            }
          } else {
            console.log('在线模式，使用服务器生成');
            // 在线模式应该通过服务器API生成，这里应该通过API调用获得结果
            // 由于当前服务器接口未提供，这里会报错，这是正确的行为
            this.generateWithServer(data).catch(error => {
              console.error('服务器生成失败:', error);
              MessageUtil.showNetworkError(error);
            });
          }
        }, 500);
        
      } catch (error) {
        console.error('解析参数失败:', error);
        wx.showToast({
          title: '参数错误',
          icon: 'none'
        });
      }
    }
  },

  // 初始化屏幕信息（同步执行，确保后续计算准确）
  initScreenInfo() {
    try {
      const systemInfo = wx.getSystemInfoSync();
      const screenWidth = systemInfo.screenWidth || systemInfo.windowWidth || 375;
      
      console.log('屏幕信息初始化:', {
        screenWidth: screenWidth,
        screenHeight: systemInfo.screenHeight,
        pixelRatio: systemInfo.pixelRatio,
        system: systemInfo.system,
        model: systemInfo.model
      });
      
      this.setData({
        screenWidth: screenWidth
      });
      
      // 存储到页面实例，供后续方法使用
      this.screenWidth = screenWidth;
      
    } catch (error) {
      console.error('获取屏幕信息失败，使用通用默认值:', error);
      // 使用iPhone 6/7/8的标准宽度作为fallback
      const fallbackWidth = 375;
      this.setData({
        screenWidth: fallbackWidth
      });
      this.screenWidth = fallbackWidth;
    }
  },

  // 获取类型显示文本
  getTypeText(type) {
    const typeMap = {
      // 条形码类型
      'Code 128': 'Code 128 条形码',
      'EAN-13': 'EAN-13 商品条码',
      'EAN-8': 'EAN-8 商品条码',
      'Code 39': 'Code 39 条形码',
      'ITF': 'ITF 交叉25码',
      // 二维码类型
      'standard': '标准二维码',
      'micro': '微型二维码'
    };
    return typeMap[type] || type;
  },

  // 设置Canvas尺寸
  setCanvasSize() {
    // 确保屏幕宽度已经正确获取
    const currentScreenWidth = this.data.screenWidth || this.screenWidth || 375;
    
    if (currentScreenWidth <= 0) {
      console.warn('屏幕宽度获取异常，使用默认值375px');
      this.setData({ screenWidth: 375 });
    }
    
    if (this.data.codeType === 'qr') {
      // 二维码是正方形
      const actualSize = this.data.qrSize;
      
      // 精确计算可用宽度
      const pagePadding = Math.floor(currentScreenWidth * 0.08); // 约8%作为页面边距
      const cardPadding = Math.floor(currentScreenWidth * 0.12); // 约12%作为卡片边距
      const maxWidth = currentScreenWidth - pagePadding - cardPadding;
      
      // 计算缩放比例 - 支持放大和缩小
      let scaleRatio = maxWidth / actualSize;
      
      // 限制缩放比例在合理范围内
      // 最小缩放：0.2（避免过度缩小）
      // 最大缩放：2.5（避免过度放大）
      scaleRatio = Math.max(0.2, Math.min(2.5, scaleRatio));
      
      console.log(`二维码缩放计算详情:
        屏幕宽度: ${currentScreenWidth}px
        实际尺寸: ${actualSize}px
        页面边距: ${pagePadding}px
        卡片边距: ${cardPadding}px
        可用宽度: ${maxWidth}px
        计算比例: ${(maxWidth / actualSize).toFixed(3)}
        最终比例: ${scaleRatio.toFixed(3)} ${scaleRatio > 1 ? '(放大)' : scaleRatio < 1 ? '(缩小)' : '(原尺寸)'}
        显示尺寸: ${Math.round(actualSize * scaleRatio)}px`);
      
      // 直接计算显示尺寸，避免使用 transform: scale()
      const displayWidth = Math.round(actualSize * scaleRatio);
      const displayHeight = Math.round(actualSize * scaleRatio);
      
      this.setData({
        canvasWidth: actualSize,
        canvasHeight: actualSize,
        displayWidth: displayWidth,
        displayHeight: displayHeight,
        scaleRatio: scaleRatio
      });
      
    } else {
      // 条形码是长方形
      const actualWidth = this.data.barcodeWidth;
      const actualHeight = Math.max(80, actualWidth * 0.3);
      
      // 计算可用宽度
      const pagePadding = Math.floor(currentScreenWidth * 0.08);
      const cardPadding = Math.floor(currentScreenWidth * 0.12);
      const maxWidth = currentScreenWidth - pagePadding - cardPadding;
      
      // 计算缩放比例 - 支持放大和缩小
      let scaleRatio = maxWidth / actualWidth;
      
      // 限制缩放比例在合理范围内
      scaleRatio = Math.max(0.2, Math.min(2.5, scaleRatio));
      
      // 如果计算出的缩放比例接近1.0，则不进行缩放
      if (scaleRatio > 0.95 && scaleRatio < 1.05) {
        scaleRatio = 1.0;
      }
      
      console.log(`条形码缩放计算详情:
        屏幕宽度: ${currentScreenWidth}px
        实际尺寸: ${actualWidth}x${actualHeight}px
        页面边距: ${pagePadding}px
        卡片边距: ${cardPadding}px
        可用宽度: ${maxWidth}px
        计算比例: ${(maxWidth / actualWidth).toFixed(3)}
        最终比例: ${scaleRatio.toFixed(3)} ${scaleRatio > 1 ? '(放大)' : scaleRatio < 1 ? '(缩小)' : '(原尺寸)'}
        显示尺寸: ${Math.round(actualWidth * scaleRatio)}x${Math.round(actualHeight * scaleRatio)}px`);
      
      // 直接计算显示尺寸，避免使用 transform: scale()
      const displayWidth = Math.round(actualWidth * scaleRatio);
      const displayHeight = Math.round(actualHeight * scaleRatio);
      
      this.setData({
        canvasWidth: actualWidth,
        canvasHeight: actualHeight,
        displayWidth: displayWidth,
        displayHeight: displayHeight,
        scaleRatio: scaleRatio
      });
    }
  },

  // 绘制二维码
  drawQRCodes() {
    if (this.data.batchMode) {
      this.drawBatchQRCodes();
    } else {
      this.drawSingleQRCode();
    }
  },

  // 绘制条形码
  drawBarcodes() {
    if (this.data.batchMode) {
      this.drawBatchBarcodes();
    } else {
      this.drawSingleBarcode();
    }
  },

  // 绘制单个二维码
  drawSingleQRCode() {
    try {
      if (this.data.qrType === 'micro') {
        // 微型二维码仅支持在线生成
        wx.showToast({
          title: '微型二维码仅支持在线生成',
          icon: 'none'
        });
        return;
      } else {
        // 使用标准二维码库 - 使用显示尺寸进行绘制
        drawQrcode({
          canvasId: 'barcodeCanvas',
          text: this.data.content,
          width: this.data.displayWidth,
          height: this.data.displayHeight,
          foreground: this.data.foregroundColor,
          background: this.data.backgroundColor,
          _this: this
        });
      }
    } catch (error) {
      console.error('绘制二维码失败:', error);
      wx.showToast({
        title: '生成失败',
        icon: 'none'
      });
    }
  },

  // 绘制单个条形码
  drawSingleBarcode() {
    const ctx = wx.createCanvasContext('barcodeCanvas', this);
    // 使用显示尺寸进行绘制
    this.drawBarcodeOnCanvas(ctx, this.data.content, this.data.displayWidth, this.data.displayHeight);
  },

  // 绘制批量二维码
  drawBatchQRCodes() {
    // 计算批量模式下的缩放比例
    const screenWidth = this.data.screenWidth || 375;
    const itemWidth = 150; // 二维码固定宽度
    const availableWidth = screenWidth * 0.3; // 可用宽度约为屏幕的30%
    const batchScaleRatio = Math.min(1.0, availableWidth / itemWidth);
    
    // 计算批量显示尺寸
    const batchDisplayWidth = Math.round(itemWidth * batchScaleRatio);
    const batchDisplayHeight = Math.round(itemWidth * batchScaleRatio);
    
    this.setData({
      batchScaleRatio: batchScaleRatio,
      batchDisplayWidth: batchDisplayWidth,
      batchDisplayHeight: batchDisplayHeight
    });
    
    this.data.barcodes.forEach((item, index) => {
      const canvasId = `barcodeCanvas${index}`;
      
      setTimeout(() => {
        try {
          if (this.data.qrType === 'micro') {
            // 微型二维码仅支持在线生成
            console.log(`批量第${index}个微型二维码跳过（仅支持在线生成）`);
            return;
          } else {
            // 标准二维码 - 使用批量显示尺寸
            drawQrcode({
              canvasId: canvasId,
              text: item.content,
              width: this.data.batchDisplayWidth,
              height: this.data.batchDisplayHeight,
              foreground: this.data.foregroundColor,
              background: this.data.backgroundColor,
              _this: this
            });
          }
        } catch (error) {
          console.error(`绘制第${index}个二维码失败:`, error);
        }
      }, index * 100);
    });
  },

  // 绘制批量条形码
  drawBatchBarcodes() {
    // 计算批量模式下的缩放比例
    const screenWidth = this.data.screenWidth || 375;
    const itemWidth = 200; // 条形码固定宽度
    const itemHeight = 80; // 条形码固定高度
    const availableWidth = screenWidth * 0.35; // 可用宽度约为屏幕的35%
    const batchScaleRatio = Math.min(1.0, availableWidth / itemWidth);
    
    // 计算批量显示尺寸
    const batchDisplayWidth = Math.round(itemWidth * batchScaleRatio);
    const batchDisplayHeight = Math.round(itemHeight * batchScaleRatio);
    
    this.setData({
      batchScaleRatio: batchScaleRatio,
      batchDisplayWidth: batchDisplayWidth,
      batchDisplayHeight: batchDisplayHeight
    });
    
    this.data.barcodes.forEach((item, index) => {
      setTimeout(() => {
        const ctx = wx.createCanvasContext(`barcodeCanvas${index}`, this);
        // 使用批量显示尺寸进行绘制
        this.drawBarcodeOnCanvas(ctx, item.content, this.data.batchDisplayWidth, this.data.batchDisplayHeight);
      }, index * 100);
    });
  },

  // 在Canvas上绘制条形码
  drawBarcodeOnCanvas(ctx, content, width, height) {
    try {
      const pattern = this.generateBarcodePattern(content);
      if (!pattern) {
        throw new Error('无法生成条形码图案');
      }
      
      // 获取设备像素比，提高绘制质量
      const systemInfo = wx.getSystemInfoSync();
      const pixelRatio = systemInfo.pixelRatio || 2;
      
      // 计算实际绘制尺寸（考虑像素密度）
      const drawWidth = width * pixelRatio;
      const drawHeight = height * pixelRatio;
      
      // 设置Canvas尺寸
      ctx.scale(pixelRatio, pixelRatio);
      
      // 清空画布
      ctx.setFillStyle(this.data.backgroundColor || '#ffffff');
      ctx.fillRect(0, 0, width, height);
      
      // 绘制条形码
      const barWidth = width / pattern.length;
      
      // 将字符串转换为数组进行遍历
      for (let i = 0; i < pattern.length; i++) {
        if (pattern[i] === '1') {
          ctx.setFillStyle(this.data.foregroundColor || '#000000');
          ctx.fillRect(i * barWidth, 0, barWidth, height * 0.8);
        }
      }
      
      // 绘制文本 - 根据Canvas大小动态调整字体大小
      const fontSize = Math.max(10, Math.min(20, height * 0.15));
      ctx.setFillStyle(this.data.foregroundColor || '#000000');
      ctx.setFontSize(fontSize);
      ctx.setTextAlign('center');
      ctx.fillText(content, width / 2, height * 0.95);
      
      // 使用与二维码库相同的draw方式，确保渲染完成
      ctx.draw(false, () => {
        console.log('条形码Canvas绘制完成，尺寸:', width, 'x', height, '像素比:', pixelRatio);
      });
    } catch (error) {
      console.error('绘制条形码失败:', error);
      wx.showToast({
        title: '生成条形码失败',
        icon: 'none'
      });
    }
  },

  // 生成条形码图案（标准Code 128实现）
  generateBarcodePattern(content) {
    // 标准Code 128编码表 (值0-106: 0-102数据 + 103-105起始码 + 106停止码)
    const CODE128_PATTERNS = [
      // 值 0-9
      '11011001100', '11001101100', '11001100110', '10010011000', '10010001100',
      '10001001100', '10011001000', '10011000100', '10001100100', '11001001000',
      // 值 10-19  
      '11001000100', '11000100100', '10110011100', '10011011100', '10011001110',
      '10111001100', '10011101100', '10011100110', '11001110010', '11001011100',
      // 值 20-29
      '11001001110', '11011100100', '11001110100', '11101101110', '11101001100',
      '11100101100', '11100100110', '11101100100', '11100110100', '11100110010',
      // 值 30-39
      '11011011000', '11011000110', '11000110110', '10100011000', '10001011000',
      '10001000110', '10110001000', '10001101000', '10001100010', '11010001000',
      // 值 40-49
      '11000101000', '11000100010', '10110111000', '10110001110', '10001101110',
      '10111011000', '10111000110', '10001110110', '11101110110', '11010001110',
      // 值 50-59
      '11000101110', '11011101000', '11011100010', '11011101110', '11101011000',
      '11101000110', '11100010110', '11101101000', '11101100010', '11100011010',
      // 值 60-69
      '11101111010', '11001000010', '11110001010', '10100110000', '10100001100',
      '10010110000', '10010000110', '10000101100', '10000100110', '10110010000',
      // 值 70-79
      '10110000100', '10011010000', '10011000010', '10000110100', '10000110010',
      '11000010010', '11001010000', '11110111010', '11000010100', '10001111010',
      // 值 80-89
      '10100111100', '10010111100', '10010011110', '10111100100', '10011110100',
      '10011110010', '11110100100', '11110010100', '11110010010', '11011011110',
      // 值 90-99
      '11011110110', '11110110110', '10101111000', '10100011110', '10001011110',
      '10111101000', '10111100010', '11110101000', '11110100010', '10111011110',
      // 值 100-102 (FNC4, Code A, FNC1)
      '10111101110', '11101011110', '11110101110',
      // 值 103-105 (Start A, Start B, Start C)
      '11010000100', '11010010000', '11010011100',
      // 值 106 (Stop)
      '1100011101011'
    ];
    
    // 验证输入
    if (!content || content.length === 0) {
      console.error('内容不能为空');
      return null;
    }
    
    try {
      // Start Code B (值104) - 用于ASCII 32-127字符
      const START_CODE_B = 104;
      let pattern = CODE128_PATTERNS[START_CODE_B];
      let checksum = START_CODE_B; // 起始码也参与校验计算
      
      // 编码每个字符
      for (let i = 0; i < content.length; i++) {
        const char = content.charAt(i);
        const ascii = char.charCodeAt(0);
        
        // Code 128 Set B: ASCII 32-127 映射到值 0-95
        if (ascii >= 32 && ascii <= 127) {
          const codeValue = ascii - 32; // 转换为Code 128值
          
          // 验证值范围 (0-95对应ASCII 32-127)
          if (codeValue >= 0 && codeValue <= 95) {
            pattern += CODE128_PATTERNS[codeValue];
            // 校验和计算：值 × 位置权重，起始码位置为0，数据从位置1开始
            checksum += codeValue * (i + 1);
          } else {
            console.error(`字符值超出Code Set B范围: ${char} (ASCII: ${ascii}, 值: ${codeValue})`);
            return null;
          }
        } else {
          console.error(`不支持的ASCII字符: ${char} (ASCII: ${ascii})`);
          return null;
        }
      }
      
      // 计算校验码 (modulo 103)
      const checksumValue = checksum % 103;
      
      // 验证校验码值范围
      if (checksumValue < 0 || checksumValue >= CODE128_PATTERNS.length - 1) {
        console.error(`校验码值超出范围: ${checksumValue}`);
        return null;
      }
      
      // 添加校验码
      pattern += CODE128_PATTERNS[checksumValue];
      
      // 添加停止码 (值106，索引106)
      const STOP_CODE = 106;
      pattern += CODE128_PATTERNS[STOP_CODE];
      
      console.log('Code 128标准生成详情:', {
        content: content,
        contentLength: content.length,
        startCode: START_CODE_B,
        checksumCalculation: checksum,
        checksumValue: checksumValue,
        stopCode: STOP_CODE,
        totalPatternLength: pattern.length,
        expectedModules: (content.length + 3) * 11 + 2, // (数据+起始+校验+停止)*11 + 停止码额外2模块
        patternPreview: pattern.substring(0, 50) + '...'
      });
      
      return pattern;
      
    } catch (error) {
      console.error('Code 128标准生成失败:', error);
      return null;
    }
  },

  // 保存到相册
  saveToAlbum() {
    wx.showLoading({
      title: '正在保存...'
    });
    
    const canvasId = 'barcodeCanvas';
    
    const { displayWidth, displayHeight } = this.data;
    
    wx.canvasToTempFilePath({
      canvasId: canvasId,
      width: displayWidth,
      height: displayHeight,
      destWidth: displayWidth * 2, // 提高分辨率
      destHeight: displayHeight * 2,
      success: (res) => {
        this.saveImageToAlbum(res.tempFilePath);
      },
      fail: (error) => {
        console.error('生成图片失败:', error);
        wx.hideLoading();
        wx.showToast({
          title: '生成图片失败',
          icon: 'none'
        });
      }
    }, this);
  },

  // 分享条形码
  shareBarcode() {
    wx.showLoading({
      title: '正在生成分享图片...'
    });
    
    const { displayWidth, displayHeight } = this.data;
    
    wx.canvasToTempFilePath({
      canvasId: 'barcodeCanvas',
      width: displayWidth,
      height: displayHeight,
      destWidth: displayWidth * 2,
      destHeight: displayHeight * 2,
      success: (res) => {
        wx.hideLoading();
        this.shareToFriend(res.tempFilePath);
      },
      fail: (error) => {
        console.error('生成分享图片失败:', error);
        wx.hideLoading();
        wx.showToast({
          title: '生成图片失败',
          icon: 'none'
        });
      }
    }, this);
  },

  // 分享给朋友
  shareToFriend(imagePath) {
    wx.showActionSheet({
      itemList: ['发送给朋友', '分享到朋友圈', '保存图片'],
      success: (res) => {
        if (res.tapIndex === 0) {
          // 发送给朋友
          wx.showShareImageMenu({
            path: imagePath,
            fail: (error) => {
              console.error('分享失败:', error);
              wx.showToast({
                title: '分享失败',
                icon: 'none'
              });
            }
          });
        } else if (res.tapIndex === 1) {
          // 分享到朋友圈（小程序无法直接分享到朋友圈，可以保存图片让用户手动分享）
          this.saveImageToAlbum(imagePath);
        } else if (res.tapIndex === 2) {
          // 保存图片
          this.saveImageToAlbum(imagePath);
        }
      }
    });
  },

  // 保存图片到相册
  saveImageToAlbum(imagePath) {
    wx.getSetting({
      success: (res) => {
        if (res.authSetting['scope.writePhotosAlbum']) {
          // 已经授权
          this.doSaveImage(imagePath);
        } else {
          // 未授权，请求授权
          wx.authorize({
            scope: 'scope.writePhotosAlbum',
            success: () => {
              this.doSaveImage(imagePath);
            },
            fail: () => {
              wx.showModal({
                title: '提示',
                content: '需要您授权保存相册权限',
                showCancel: false,
                confirmText: '去设置',
                success: (modalRes) => {
                  if (modalRes.confirm) {
                    wx.openSetting();
                  }
                }
              });
            }
          });
        }
      }
    });
  },

  // 执行保存图片
  doSaveImage(imagePath) {
    wx.saveImageToPhotosAlbum({
      filePath: imagePath,
      success: () => {
        wx.hideLoading();
        wx.showToast({
          title: '保存成功',
          icon: 'success'
        });
      },
      fail: (error) => {
        console.error('保存失败:', error);
        wx.hideLoading();
        wx.showToast({
          title: '保存失败',
          icon: 'none'
        });
      }
    });
  },

  // 保存全部到相册
  saveAllToAlbum() {
    if (this.data.barcodes.length === 0) {
      wx.showToast({
        title: '没有要保存的内容',
        icon: 'none'
      });
      return;
    }
    
    wx.showModal({
      title: '确认保存',
      content: `确定要保存全部 ${this.data.barcodes.length} 个${this.data.codeType === 'qr' ? '二维码' : '条形码'}到相册吗？`,
      success: (res) => {
        if (res.confirm) {
          this.setData({
            loading: true,
            loadingText: '正在批量保存...'
          });
          this.saveBatchImages();
        }
      }
    });
  },

  // 批量保存图片
  saveBatchImages() {
    let savedCount = 0;
    const totalCount = this.data.barcodes.length;
    
    const saveNext = (index) => {
      if (index >= totalCount) {
        this.setData({
          loading: false
        });
        wx.showToast({
          title: `成功保存${savedCount}张图片`,
          icon: 'success'
        });
        return;
      }
      
      const canvasId = `barcodeCanvas${index}`;
      
      wx.canvasToTempFilePath({
        canvasId: canvasId,
        width: this.data.batchDisplayWidth,
        height: this.data.batchDisplayHeight,
        success: (res) => {
          this.doSaveImage(res.tempFilePath);
          savedCount++;
          setTimeout(() => saveNext(index + 1), 500);
        },
        fail: (error) => {
          console.error(`保存第${index + 1}个图片失败:`, error);
          setTimeout(() => saveNext(index + 1), 500);
        }
      }, this);
    };
    
    saveNext(0);
  },

  // 分享全部
  shareAll() {
    wx.showToast({
      title: '批量分享功能开发中',
      icon: 'none'
    });
  },

  // 逐个分享
  async shareAllOneByOne() {
    if (this.data.barcodes.length === 0) {
      wx.showToast({
        title: '没有要分享的内容',
        icon: 'none'
      });
      return;
    }
    
    this.setData({
      loading: true,
      loadingText: '正在准备分享...'
    });
    
    try {
      for (let i = 0; i < this.data.barcodes.length; i++) {
        const canvasId = `barcodeCanvas${i}`;
        
        const tempFilePath = await new Promise((resolve, reject) => {
          wx.canvasToTempFilePath({
            canvasId: canvasId,
            width: this.data.batchDisplayWidth,
            height: this.data.batchDisplayHeight,
            success: (res) => resolve(res.tempFilePath),
            fail: reject
          }, this);
        });
        
        // 这里可以调用分享API，或者保存到临时目录
        console.log(`第${i + 1}个码的临时文件路径:`, tempFilePath);
      }
      
      this.setData({
        loading: false
      });
      
      wx.showToast({
        title: '准备完成',
        icon: 'success'
      });
      
    } catch (error) {
      console.error('批量分享失败:', error);
      this.setData({
        loading: false
      });
      wx.showToast({
        title: '分享失败',
        icon: 'none'
      });
    }
  },

  // 重新生成
  regenerate() {
    wx.navigateBack();
  },

  // 保存到历史记录
  saveToHistory(data) {
    const historyManager = require('../../utils/history-manager.js');
    historyManager.saveQRGenerateRecord(data);
  },

  // 分享给朋友
  onShareAppMessage() {
    return {
      title: `我生成了一个${this.data.codeType === 'qr' ? '二维码' : '条形码'}`,
      path: '/pages/index/index'
    };
  },

  // 检查离线模式状态
  checkOfflineMode() {
    const app = getApp();
    const isOffline = app.isOfflineMode();
    console.log('结果页检查离线模式状态:', isOffline);
    this.setData({ isOfflineMode: isOffline });
  },

  // 本地生成二维码
  generateQRLocally(data) {
    const content = Array.isArray(data.content) ? data.content[0] : data.content;
    const trimmedContent = content.trim();
    
    if (data.type === 'micro') {
      // 微型二维码仅支持在线生成
      MessageUtil.showError('微型二维码仅支持在线生成，请确保网络连接正常');
      return;
    } else {
      // 生成标准二维码
      this.generateStandardQRLocally(trimmedContent, data);
    }
  },

  // 本地生成标准二维码
  generateStandardQRLocally(content, data) {
    try {
      // 使用页面设置的显示尺寸，确保与WXML中的显示尺寸一致
              drawQrcode({
          width: this.data.displayWidth,
          height: this.data.displayHeight,
          canvasId: 'barcodeCanvas',
          text: content,
          foreground: data.foregroundColor || '#000000',
          background: data.backgroundColor || '#ffffff',
          _this: this,
          callback: (res) => {
            console.log('标准二维码本地生成完成，尺寸:', this.data.displayWidth, 'x', this.data.displayHeight);
            this.handleLocalGenerateSuccess();
          }
        });
    } catch (error) {
      console.error('标准二维码本地生成失败:', error);
      MessageUtil.showError('生成失败: ' + error.message);
    }
  },



  // 本地生成条形码
  generateBarcodeLocally(data) {
    const content = Array.isArray(data.content) ? data.content[0] : data.content;
    const trimmedContent = content.trim();
    
    // 简单的兼容性检查
    if (!trimmedContent || trimmedContent.length === 0) {
      MessageUtil.showError('请输入有效内容');
      return;
    }
    
    // 检查内容长度（Code 128 通常支持较长的内容）
    if (trimmedContent.length > 100) {
      MessageUtil.showError('内容过长，请减少字符数量');
      return;
    }
    
    try {
      console.log('[generateBarcodeLocally] 开始使用JsBarcode生成条形码:', trimmedContent);
      
      // 使用Canvas 2D API获取canvas节点
      wx.createSelectorQuery()
        .in(this)
        .select('#barcodeCanvas')
        .fields({
          node: true,
          size: true
        })
        .exec((res) => {
          if (!res[0] || !res[0].node) {
            console.error('[generateBarcodeLocally] 无法获取canvas节点');
            MessageUtil.showError('Canvas初始化失败');
            return;
          }
          
          const canvas = res[0].node;
          const dpr = wx.getSystemInfoSync().pixelRatio || 1;
          
          // 设置canvas尺寸为显示尺寸（简化处理）
          canvas.width = this.data.displayWidth;
          canvas.height = this.data.displayHeight;
          
          console.log('[generateBarcodeLocally] Canvas设置:', {
            width: canvas.width,
            height: canvas.height,
            displayWidth: this.data.displayWidth,
            displayHeight: this.data.displayHeight,
            dpr: dpr
          });
          
          // 使用JsBarcode生成条形码，使用逻辑尺寸
          const options = {
            width: 2,
            height: this.data.displayHeight - 20, // 留出一些边距
            displayValue: false, // 不显示文本，避免重叠
            background: data.backgroundColor || '#ffffff',
            lineColor: data.foregroundColor || '#000000',
            margin: 10,
            marginTop: 10,
            marginBottom: 10,
            marginLeft: 10,
            marginRight: 10
          };
          
          try {
            JsBarcodeUtil.generateCode128(canvas, trimmedContent, options);
            console.log('[generateBarcodeLocally] 条形码生成完成');
            this.handleLocalGenerateSuccess();
          } catch (error) {
            console.error('[generateBarcodeLocally] JsBarcode生成失败:', error);
            MessageUtil.showError('生成失败: ' + error.message);
          }
        });
        
    } catch (error) {
      console.error('[generateBarcodeLocally] 条形码本地生成失败:', error);
      MessageUtil.showError('生成失败: ' + error.message);
    }
  },

  // 服务器生成
  async generateWithServer(data) {
    try {
      const params = {
        codeType: this.data.codeType === 'qr' ? 'qrcode' : 'barcode',
        subType: this.data.codeType === 'qr' ? data.type : data.barcodeType,
        content: data.content,
        batchMode: data.batchMode,
        options: {
          foregroundColor: data.foregroundColor,
          backgroundColor: data.backgroundColor,
          size: this.data.codeType === 'qr' ? data.size : data.barcodeWidth
        }
      };

      // 调用API服务
      const response = await apiService.generateCode(params);
      
      if (data.batchMode) {
        // 批量生成，处理服务器返回的批量结果
        this.handleServerBatchResult(response.data);
      } else {
        // 单个生成，处理服务器返回的单个结果
        this.handleServerSingleResult(response.data);
      }
    } catch (error) {
      throw error;
    }
  },

  // 处理服务器单个生成结果
  handleServerSingleResult(data) {
    // 这里应该根据服务器返回的数据来显示结果
    // 由于服务器接口未实现，这个方法暂时为空
    console.log('服务器单个生成结果:', data);
  },

  // 处理服务器批量生成结果
  handleServerBatchResult(data) {
    // 这里应该根据服务器返回的数据来显示批量结果
    // 由于服务器接口未实现，这个方法暂时为空
    console.log('服务器批量生成结果:', data);
  },

  // 处理本地生成成功
  handleLocalGenerateSuccess() {
    // 本地生成完成，但不自动保存到相册，让用户自己点击按钮保存
    console.log('本地生成完成，等待用户操作');
    MessageUtil.showSuccess((this.data.codeType === 'qr' ? '二维码' : '条形码') + '生成完成');
  }
});